package juego.mundo;

import java.awt.Color;
import java.awt.Graphics;
import java.io.BufferedReader;
import java.io.File;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;

import javax.swing.ImageIcon;

import juego.sprites.Criatura;
import juego.sprites.EntidadMovil;
import juego.sprites.Jugador;
import juego.util.AABB;
import juego.util.Vector2D;


public class Mapa {
		
	private ArrayList<ImageIcon> imagenes;
	private char[][] losas; // Matriz en la que se carga el mapa, se utiliza para inicializar
	private Losa[][] cLosas;
	private int nFilas;
	private int nColumnas;
	private ImageIcon imgFondo;
	private int tamLosa;
	
	private Jugador jugador;
	private int xInicioJugador;
	private int yInicioJugador;
	private ArrayList<Criatura> enemigos;
	
	public Mapa() {
		this.imagenes = new ArrayList<ImageIcon>();
		this.nFilas = 0;
		this.nColumnas = 0;
		this.losas = null;
		this.imgFondo = null;
		this.tamLosa = 32;
		this.xInicioJugador = 0;
		this.yInicioJugador = 0;
		this.enemigos = new ArrayList<Criatura>();
	}
	
	public void agregarImagen(char id, ImageIcon imagen) {
		imagen.setDescription(""+id);
		imagenes.add(imagen);
	}
	
	public ImageIcon buscarImagen(char id) {
		for (int i = 0; i < imagenes.size(); i++) {
			if (imagenes.get(i).getDescription().compareTo(""+id) == 0) {
				return imagenes.get(i);
			}
		}
		return null;
	}
	
	public void cargarMapa(String ruta) throws IOException, NumberFormatException {
		InputStreamReader isr = new InputStreamReader(ClassLoader.getSystemResourceAsStream(ruta));
		BufferedReader br = new BufferedReader(isr);
		String linea;
		int j = 0;
		nFilas = Integer.parseInt(br.readLine());
		nColumnas = Integer.parseInt(br.readLine());
		losas = new char[nFilas][nColumnas];
		cLosas = new Losa[nFilas][nColumnas];
		
		while (true) {
			linea = br.readLine();
			if (linea == null) {
				br.close();
				break;
			}
			for (int i = 0; (i < linea.length()) && (i < nColumnas) && (j < nFilas); i++) {
				losas[i][j] = linea.charAt(i);
			}
			j++;
		}
	}
	
	public void inicializarMapa() {
		int posX, posY;
		for (int i = 0; i < nFilas; i++) {
			for (int j = 0; j < nColumnas; j++) {
				if (losas[i][j] == 'J') {
					jugador = new Jugador(true, 500);
					jugador.agregarEtapaAnimPorDefecto(new ImageIcon(ClassLoader.getSystemResource("recursos"+File.separator+"imagenes"+java.io.File.separator+"jugadorVerde.png")));
					jugador.agregarEtapaAnimPorDefecto(new ImageIcon(ClassLoader.getSystemResource("recursos"+File.separator+"imagenes"+java.io.File.separator+"jugadorVerde2.png")));
					jugador.agregarEtapaAnimPorDefecto(new ImageIcon(ClassLoader.getSystemResource("recursos"+File.separator+"imagenes"+java.io.File.separator+"jugadorVerde3.png")));
					jugador.agregarEtapaAnimIzq(new ImageIcon(ClassLoader.getSystemResource("recursos"+File.separator+"imagenes"+java.io.File.separator+"jugadorRojo.png")));
					jugador.agregarEtapaAnimIzq(new ImageIcon(ClassLoader.getSystemResource("recursos"+File.separator+"imagenes"+java.io.File.separator+"jugadorRojo2.png")));
					jugador.agregarEtapaAnimIzq(new ImageIcon(ClassLoader.getSystemResource("recursos"+File.separator+"imagenes"+java.io.File.separator+"jugadorRojo3.png")));
					jugador.agregarEtapaAnimDch(new ImageIcon(ClassLoader.getSystemResource("recursos"+File.separator+"imagenes"+java.io.File.separator+"jugadorAzul.png")));
					jugador.agregarEtapaAnimDch(new ImageIcon(ClassLoader.getSystemResource("recursos"+File.separator+"imagenes"+java.io.File.separator+"jugadorAzul2.png")));
					jugador.agregarEtapaAnimDch(new ImageIcon(ClassLoader.getSystemResource("recursos"+File.separator+"imagenes"+java.io.File.separator+"jugadorAzul3.png")));
					
					xInicioJugador = getPixelLosa(i);
					yInicioJugador = getPixelLosa(j) + tamLosa - jugador.getAnimacionPorDefecto().getEstadoActual().getIconHeight();
					jugador.setX(xInicioJugador);
					jugador.setY(yInicioJugador);
				}
				if (losas[i][j] == 'E') {
					Criatura enemigo = new Criatura(false, 200);
					enemigo.agregarEtapaAnimPorDefecto(new ImageIcon(ClassLoader.getSystemResource("recursos"+File.separator+"imagenes"+java.io.File.separator+"jugador2.png")));
					posX = getPixelLosa(i);
					posY = getPixelLosa(j) + tamLosa - enemigo.getAnimacionPorDefecto().getEstadoActual().getIconHeight();
					enemigo.setX(posX);
					enemigo.setY(posY);					
					enemigo.getAceleracion().setX(-50);
					enemigo.getAceleracion().setY(-50);
					enemigos.add(enemigo);
				}
				// Creamos las losas
				if (losas[i][j] == 'a') {
					cLosas[i][j] = new Losa(getPixelLosa(i), getPixelLosa(j), 'a', false, false, false, true);
				}
				if (losas[i][j] == 'b') {
					cLosas[i][j] = new Losa(getPixelLosa(i), getPixelLosa(j), 'b', true, false, false, false);
				}
				if (losas[i][j] == 'c') {
					cLosas[i][j] = new Losa(getPixelLosa(i), getPixelLosa(j), 'c', false, false, true, false);
				}
				if (losas[i][j] == 'd') {
					cLosas[i][j] = new Losa(getPixelLosa(i), getPixelLosa(j), 'd', false, true, false, false);
				}
				if (losas[i][j] == 'e') {
					cLosas[i][j] = new Losa(getPixelLosa(i), getPixelLosa(j), 'e', false, false, false, false);
				}
				if (losas[i][j] == 'f') {
					cLosas[i][j] = new Losa(getPixelLosa(i), getPixelLosa(j), 'f', false, false, false, false);
				}
				if (losas[i][j] == 'g') {
					cLosas[i][j] = new Losa(getPixelLosa(i), getPixelLosa(j), 'g', false, false, false, false);
				}
				if (losas[i][j] == 'h') {
					cLosas[i][j] = new Losa(getPixelLosa(i), getPixelLosa(j), 'h', false, false, false, false);
				}
				if (losas[i][j] == 'i') {
					cLosas[i][j] = new Losa(getPixelLosa(i), getPixelLosa(j), 'i', false, true, true, false);
				}
				if (losas[i][j] == 'j') {
					cLosas[i][j] = new Losa(getPixelLosa(i), getPixelLosa(j), 'j', true, false, true, false);
				}
				if (losas[i][j] == 'k') {
					cLosas[i][j] = new Losa(getPixelLosa(i), getPixelLosa(j), 'k', true, true, true, true);
				}
				if (losas[i][j] == 'l') {
					cLosas[i][j] = new Losa(getPixelLosa(i), getPixelLosa(j), 'l', true, false, false, true);
				}
				if (losas[i][j] == 'm') {
					cLosas[i][j] = new Losa(getPixelLosa(i), getPixelLosa(j), 'm', false, true, false, true);
				}
				if (losas[i][j] == 'n') {
					cLosas[i][j] = new Losa(getPixelLosa(i), getPixelLosa(j), 'n', true, false, true, true);
				}
				if (losas[i][j] == 'o') {
					cLosas[i][j] = new Losa(getPixelLosa(i), getPixelLosa(j), 'o', false, false, true, true);
				}
				if (losas[i][j] == 'p') {
					cLosas[i][j] = new Losa(getPixelLosa(i), getPixelLosa(j), 'p', false, true, true, true);
				}
				if (losas[i][j] == 'q') {
					cLosas[i][j] = new Losa(getPixelLosa(i), getPixelLosa(j), 'q', false, false, false, false);
				}
				if (losas[i][j] == 'z') {
					cLosas[i][j] = new Losa(getPixelLosa(i), getPixelLosa(j), 'z', false, false, false, false);
				}
			}
		}		
	}
	
	public void paint(Graphics g, int ancho, int alto) {
		ImageIcon img;
		// Fondo
		if (imgFondo == null) {
			g.setColor(Color.WHITE);
			g.fillRect(0, 0, ancho, alto);
		} else {
			g.drawImage(imgFondo.getImage(), 0, 0, null);
		}
		// Losas
		for (int i = 0; i < nFilas; i++) {
			for (int j = 0; j < nColumnas; j++) {
				if (cLosas[i][j] != null) {
					img = buscarImagen(cLosas[i][j].getID());
					if (img != null) {
						g.drawImage(img.getImage(), cLosas[i][j].getX(), cLosas[i][j].getY(), null);
					} else {
						g.setColor(Color.BLACK);
						g.fillRect(cLosas[i][j].getX(), cLosas[i][j].getY(), tamLosa, tamLosa);
					}
					
				}
			}
		}
		// Enemigos
		for (int i = 0; i < enemigos.size(); i++) {
			if (!enemigos.get(i).isMuerto()) {
				enemigos.get(i).paint(g);
			}
		}
		// Jugador
		jugador.paint(g);
	}
	
	public void actualizar(boolean teclaIzq, boolean teclaDch, boolean teclaArr, boolean teclaAba, double dt) {
		moverEnemigos(dt);
    	jugador.actualizarAnimacion(dt);
    	moverJugador(teclaIzq, teclaDch, teclaArr, teclaAba, dt);
    	actualizarPosicion(jugador, dt);
    	gestionarColisionJugadorEntidades();
	}
	
	private void moverEnemigos(double dt) {
		for (int i = 0; i < enemigos.size(); i++) {
			actualizarPosicion(enemigos.get(i), dt);
		}
	}
	
	private void moverJugador(boolean teclaIzq, boolean teclaDch, boolean teclaArr, boolean teclaAba, double dt) {
		
		if (teclaIzq && teclaAba) {
			jugador.getAceleracion().setX(-1000);
			jugador.getAceleracion().setY(1000);
		} else if (teclaIzq && teclaArr){
			jugador.getAceleracion().setX(-1000);
			jugador.getAceleracion().setY(-1000);
		} else if (teclaIzq){
			jugador.getAceleracion().setX(-1000);
		} else if (teclaDch && teclaAba){
			jugador.getAceleracion().setX(1000);
			jugador.getAceleracion().setY(1000);
		} else if (teclaDch && teclaArr){
			jugador.getAceleracion().setX(1000);
			jugador.getAceleracion().setY(-1000);
		} else if (teclaDch){
			jugador.getAceleracion().setX(1000);
		} else if (teclaArr){
			jugador.getAceleracion().setY(-1000);
		} else if (teclaAba){
			jugador.getAceleracion().setY(1000);
		}
	}
	
	/**
	 * Actualiza la posicion de una EntidadMovil.
	 * @param entidad
	 * @param dt
	 */
	public void actualizarPosicion(EntidadMovil entidad, double dt) {
		double nuevaPosX = entidad.calcularNuevaPosX(dt);
		double nuevaPosY = entidad.calcularNuevaPosY(dt);
		gestionarColisionesMapa(entidad, nuevaPosX, nuevaPosY, dt);
	}
	
	/**
	 * En caso de que, en el paso de la posicion actual a la nueva posicion, se detecte una colision
	 * de la EntidadMovil con el mapa, se corrige.
	 * @param entidad
	 * @param nuevaPosX
	 * @param nuevaPosY
	 * @param dt
	 */
	private void gestionarColisionesMapa(EntidadMovil entidad, double nuevaPosX, double nuevaPosY, double dt) {
		AABB aabbEntidad, aabbLosa;
		Vector2D aux;
		Vector2D correccion = new Vector2D();
		boolean colisionX = false;
		boolean colisionY = false;
		ColisionMapa colision = buscarColisionesMapa(entidad, nuevaPosX, nuevaPosY);
		aabbEntidad = new AABB((int) colision.getPosicionX(), (int) colision.getPosicionY(), entidad.getWidth(), entidad.getHeight());
		
		if (!colision.hayColision()) {
			entidad.moverX(dt);
			entidad.moverY(dt);
			return;
		}

		for (int i = 0; i < colision.getLosas().size(); i++) {
			aabbLosa = new AABB(colision.getLosas().get(i).getX(), colision.getLosas().get(i).getY(), tamLosa, tamLosa);
			aux = aabbEntidad.getPenetracion(aabbLosa);
			// Averiguamos el eje que tiene preferencia a la hora de corregir la colision
			if (Math.abs(aux.getX()) < Math.abs(aux.getY())) {
				// Averiguamos el sentido de la correccion en el eje X
				if (aux.getX() < 0) {
					// Intentamos corregir hacia la izquierda, si la losa no es colisionable por
					// la izquierda, se intenta corregir en el eje Y
					if (colision.getLosas().get(i).isColisionableIzq()) {
						correccion.setX(Math.min(correccion.getX(), aux.getX()));
						entidad.setX(colision.getPosicionX());
						entidad.setY(colision.getPosicionY());
						colisionX = true;
					} else {
						if ((aux.getY() < 0) && (colision.getLosas().get(i).isColisionableArr())) {
							// Corregimos hacia arriba
							correccion.setY(Math.min(correccion.getY(), aux.getY()));
							entidad.setX(colision.getPosicionX());
							entidad.setY(colision.getPosicionY());
							colisionY = true;
						} else if ((aux.getY() > 0) && (colision.getLosas().get(i).isColisionableAba())) {
							// Corregimos hacia abajo
							correccion.setY(Math.max(correccion.getY(), aux.getY()));
							entidad.setX(colision.getPosicionX());
							entidad.setY(colision.getPosicionY());
							colisionY = true;
						}
					}
				} else if (aux.getX() > 0) {
					// Intentamos corregir hacia la derecha, si la losa no es colisionable por
					// la derecha, se intenta corregir en el eje Y
					if (colision.getLosas().get(i).isColisionableDch()) {
						correccion.setX(Math.max(correccion.getX(), aux.getX()));
						entidad.setX(colision.getPosicionX());
						entidad.setY(colision.getPosicionY());
						colisionX = true;
					} else {
						if ((aux.getY() < 0) && (colision.getLosas().get(i).isColisionableArr())) {
							// Corregimos hacia arriba
							correccion.setY(Math.min(correccion.getY(), aux.getY()));
							entidad.setX(colision.getPosicionX());
							entidad.setY(colision.getPosicionY());
							colisionY = true;
						} else if ((aux.getY() > 0) && (colision.getLosas().get(i).isColisionableAba())) {
							// Corregimos hacia abajo
							correccion.setY(Math.max(correccion.getY(), aux.getY()));
							entidad.setX(colision.getPosicionX());
							entidad.setY(colision.getPosicionY());
							colisionY = true;
						}
					}
				}
			} else if (Math.abs(aux.getX()) > Math.abs(aux.getY())) {
				// Averiguamos el sentido de la correccion en el eje Y
				if (aux.getY() < 0) {
					// Intentamos corregir hacia arriba, si la losa no es colisionable por
					// arriba, se intenta corregir en el eje X
					if (colision.getLosas().get(i).isColisionableArr()) {
						correccion.setY(Math.min(correccion.getY(), aux.getY()));
						entidad.setX(colision.getPosicionX());
						entidad.setY(colision.getPosicionY());
						colisionY = true;
					} else {
						if ((aux.getX() < 0) && (colision.getLosas().get(i).isColisionableIzq())) {
							// Corregimos hacia la izquierda
							correccion.setX(Math.min(correccion.getX(), aux.getX()));
							entidad.setX(colision.getPosicionX());
							entidad.setY(colision.getPosicionY());
							colisionX = true;
						} else if ((aux.getX() > 0) && (colision.getLosas().get(i).isColisionableDch())) {
							// Corregimos hacia la derecha
							correccion.setX(Math.max(correccion.getX(), aux.getX()));
							entidad.setX(colision.getPosicionX());
							entidad.setY(colision.getPosicionY());
							colisionX = true;
						}
					}
				} else if (aux.getY() > 0) {
					// Intentamos corregir hacia abajo, si la losa no es colisionable por
					// abajo, se intenta corregir en el eje X
					if (colision.getLosas().get(i).isColisionableAba()) {
						correccion.setY(Math.max(correccion.getY(), aux.getY()));
						entidad.setX(colision.getPosicionX());
						entidad.setY(colision.getPosicionY());
						colisionY = true;
					} else {
						if ((aux.getX() < 0) && (colision.getLosas().get(i).isColisionableIzq())) {
							// Corregimos hacia la izquierda
							correccion.setX(Math.min(correccion.getX(), aux.getX()));
							entidad.setX(colision.getPosicionX());
							entidad.setY(colision.getPosicionY());
							colisionX = true;
						} else if ((aux.getX() > 0) && (colision.getLosas().get(i).isColisionableDch())) {
							// Corregimos hacia la derecha
							correccion.setX(Math.max(correccion.getX(), aux.getX()));
							entidad.setX(colision.getPosicionX());
							entidad.setY(colision.getPosicionY());
							colisionX = true;
						}
					}
				}
			}
		}
		// Si no hay que hacer ninguna correccion, movemos el objeto
		if (correccion.getX() == 0 && correccion.getY() == 0) {
			entidad.moverX(dt);
			entidad.moverY(dt);
		} else {
			// Corregimos la colision
			entidad.setX(entidad.getX() + correccion.getX());
			entidad.setY(entidad.getY() + correccion.getY());
		}
		// Reaccion de la entidad ante la colision
		if (colisionX) {
			entidad.gestionarColisionMapaX();
		}
		if (colisionY) {
			entidad.gestionarColisionMapaY();
		}
	}
	
	/**
	 * Hace un multi-muestreo de la trayectoria de la EntidadMovil y comprueba para cada muestra si hay
	 * colisiones con el mapa. Cuando una muestra colisiona, el metodo devuelve un objeto ColisionMapa
	 * que contiene las losas con las que se ha detectado colision.
	 * @param entidad
	 * @param nuevaPosX
	 * @param nuevaPosY
	 */
	private ColisionMapa buscarColisionesMapa(EntidadMovil entidad, double nuevaPosX, double nuevaPosY) {
		int losaX1, losaY1, losaX2, losaY2, losaNuevaPosX1, losaNuevaPosX2, losaNuevaPosY1, losaNuevaPosY2;
		double distMuestreoX, distMuestreoY;
		ColisionMapa colision = new ColisionMapa();
		boolean colisionEncontrada = false;
	    // Calculamos los los limites del rango de losas en el que puede haber colision
		int losaXInicial = getLosaPixel(Math.min(entidad.getX(), nuevaPosX));
	    int losaXFinal = getLosaPixel(Math.max(entidad.getX(), nuevaPosX) + entidad.getWidth() - 1);
	    int losaYInicial = getLosaPixel(Math.min(entidad.getY(), nuevaPosY));
	    int losaYFinal = getLosaPixel(Math.max(entidad.getY(), nuevaPosY) + entidad.getHeight() - 1);
	    // Calculamos el numero de muestreos
	    int nMuestreosX = Math.abs(losaXFinal - losaXInicial);
	    int nMuestreosY = Math.abs(losaYFinal - losaYInicial);
	    int nMuestreos = Math.max(nMuestreosX, nMuestreosY);
	    // Si nMuestreos es 0, el objeto esta totalmente contenido en una losa y no se ha salido al moverse
	    if (nMuestreos > 0) {
	    	// Calculamos las distancias de muestreo en x e y
		    distMuestreoX = ((nuevaPosX - entidad.getX()) / nMuestreos);
		    distMuestreoY = ((nuevaPosY - entidad.getY()) / nMuestreos);
		    // Comprobamos si hay colision en los muestreos calculados
		    for (int i = 0; i < nMuestreos; i++) {
				losaX1 = getLosaPixel(entidad.getX() + (distMuestreoX * i));
				losaY1 = getLosaPixel(entidad.getY() + (distMuestreoY * i));
				losaX2 = getLosaPixel(((entidad.getX() + entidad.getWidth() - 1) + (distMuestreoX * i)));
				losaY2 = getLosaPixel(((entidad.getY() + entidad.getHeight() - 1) + (distMuestreoY * i)));
				
		    	// Comprobamos las 4 esquinas
		    	if (hayLosa(losaX1, losaY1)) {
		    		colision.agregarLosa(cLosas[losaX1][losaY1]);
		    		colisionEncontrada = true;
		    	}
		    	if (hayLosa(losaX2, losaY1)) {
		    		colision.agregarLosa(cLosas[losaX2][losaY1]);
		    		colisionEncontrada = true;
		    	}
		    	if (hayLosa(losaX1, losaY2)) {
		    		colision.agregarLosa(cLosas[losaX1][losaY2]);
		    		colisionEncontrada = true;
		    	}
		    	if (hayLosa(losaX2, losaY2)) {
		    		colision.agregarLosa(cLosas[losaX2][losaY2]);
		    		colisionEncontrada = true;
		    	}
		    	if (colisionEncontrada) {
		    		// Guardamos en el objeto ColisionMapa la posicion del muestreo en el que se ha detectado la colision
		    		colision.setPosicion(entidad.getX() + (distMuestreoX * i), entidad.getY() + (distMuestreoY * i));
					break;
				}
			}
		}
	    // Si no se ha encontrado colision en los muestreos se comprueba la nueva posicion
	    if (!colisionEncontrada) {
	    	losaNuevaPosX1 = getLosaPixel(nuevaPosX);
		    losaNuevaPosY1 = getLosaPixel(nuevaPosY);
		    losaNuevaPosX2 = getLosaPixel(nuevaPosX + entidad.getWidth() - 1);
		    losaNuevaPosY2 = getLosaPixel(nuevaPosY + entidad.getHeight() - 1);
		    // Comprobamos las 4 esquinas
		    if (hayLosa(losaNuevaPosX1, losaNuevaPosY1)) {
		    	colision.agregarLosa(cLosas[losaNuevaPosX1][losaNuevaPosY1]);
	    		colisionEncontrada = true;
	    	}
	    	if (hayLosa(losaNuevaPosX2, losaNuevaPosY1)) {
	    		colision.agregarLosa(cLosas[losaNuevaPosX2][losaNuevaPosY1]);
	    		colisionEncontrada = true;
	    	}
	    	if (hayLosa(losaNuevaPosX1, losaNuevaPosY2)) {
	    		colision.agregarLosa(cLosas[losaNuevaPosX1][losaNuevaPosY2]);
	    		colisionEncontrada = true;
	    	}
	    	if (hayLosa(losaNuevaPosX2, losaNuevaPosY2)) {
	    		colision.agregarLosa(cLosas[losaNuevaPosX2][losaNuevaPosY2]);
	    		colisionEncontrada = true;
	    	}
	    	if (colisionEncontrada) {
	    		colision.setPosicion(nuevaPosX, nuevaPosY);
			}
		}
	    return colision;
	}
	
	private boolean hayLosa(int x, int y) {
    	if (x < 0) x = 0;
    	if (x >= nFilas) x = nFilas -1;
    	if (y < 0) y = 0;
    	if (y >= nColumnas) y = nColumnas - 1;
    	
    	if (cLosas[x][y] != null) {
			return true;
		}
    	return false;
	}
	
	private void gestionarColisionJugadorEntidades() {
		for (int i = 0; i < enemigos.size(); i++) {
			if (jugador.comprobarColision(enemigos.get(i))) {
				jugador.setX(xInicioJugador);
				jugador.setY(yInicioJugador);
			}
		}
	}
	
	/**
	 * Devuelve la losa en la que se encuentra el pixel indicado.
	 * @param pixel
	 * @return
	 */
	public int getLosaPixel(double pixel) {
		return (int) (pixel / tamLosa);
	}
	
	/**
	 * Devuelve el pixel en el que comienza la losa indicada.
	 * @param losa
	 * @return
	 */
	public int getPixelLosa(int losa) {
		return losa * tamLosa;
	}

	public ArrayList<ImageIcon> getImagenes() {
		return imagenes;
	}

	public void setImagenes(ArrayList<ImageIcon> imagenes) {
		this.imagenes = imagenes;
	}

	public char[][] getLosas() {
		return losas;
	}

	public void setLosas(char[][] losas) {
		this.losas = losas;
	}

	public int getnFilas() {
		return nFilas;
	}

	public void setnFilas(int nFilas) {
		this.nFilas = nFilas;
	}

	public int getnColumnas() {
		return nColumnas;
	}

	public void setnColumnas(int nColumnas) {
		this.nColumnas = nColumnas;
	}

	public ImageIcon getImgFondo() {
		return imgFondo;
	}

	public void setImgFondo(ImageIcon imgFondo) {
		this.imgFondo = imgFondo;
	}

	public int getTamLosa() {
		return tamLosa;
	}
	
	public void setTamLosa(int tamLosa) {
		this.tamLosa = tamLosa;
	}

	public Jugador getJugador() {
		return jugador;
	}

	public void setJugador(Jugador jugador) {
		this.jugador = jugador;
	}

	public int getxInicioJugador() {
		return xInicioJugador;
	}

	public void setxInicioJugador(int xInicioJugador) {
		this.xInicioJugador = xInicioJugador;
	}

	public int getyInicioJugador() {
		return yInicioJugador;
	}

	public void setyInicioJugador(int yInicioJugador) {
		this.yInicioJugador = yInicioJugador;
	}

	public ArrayList<Criatura> getEnemigos() {
		return enemigos;
	}

	public void setEnemigos(ArrayList<Criatura> enemigos) {
		this.enemigos = enemigos;
	}

	public Losa[][] getcLosas() {
		return cLosas;
	}

	public void setcLosas(Losa[][] cLosas) {
		this.cLosas = cLosas;
	}
	
}
